Several devices currently exist for converting a textual multimedia scene description into content viewable by a user, among which are included:                Encoder-type devices which construct an equivalent binary content from a textual description,        Compiler-type devices which, from an assemblage of symbols, key words and rules (i.e., a computer language), make it possible to describe instructions to an execution environment which will construct an equivalent binary content,        Dynamic publishing engine-type devices which, using documents, interpret same in order to send content to a user.        
Among the above-mentioned techniques, the most widely used is of the Encoder type. It does nothing more than to translate a set of multimedia instructions expressed in one format F1 into another format F2, which format F2 being generally more compressed than the first format F1.
One disadvantage of this technique lies in the fact that it does not enable the author to translate a set of graphic scenes into an executable code which will generate content according to the execution context. Therefore, this technique is not suited to generating dynamic content.
The most advanced technique defines how a dynamic publishing engine device interprets a document and constructs content intended to be broadcasted directly, i.e., in the format used for the scene description portion of the initial document. In the following examples, such a format, for example, is an XML or HTML text format exempt of the scripts to be executed on the server.
For example, Server Pages technologies (e.g., Active Server Pages™ or XML Server Pages) supply a server script development environment for creating Web server applications, which are both dynamic and interactive. The author can associate XML or HTML pages and the script commands for creating interactive Web pages or powerful Web-based applications. The majority of active page technologies (ASP, PHP etc.) are based on an interpreted code, the execution of which requires many resources in order to provide the answer.
Java Server Pages (JSP) technologies are differentiated by the fact that they are compiled only in the case where the Java Server Pages script has been updated. These JSP technologies are faster running than completely interpreted technologies.
However, in every instance, the document is interpreted at the moment of the user request, which makes a priori validation of all of the content difficult.
In addition, these techniques do not enable a priori validation of a “dynamic service,” i.e., a set of dynamic content and navigation rules which connect said dynamic contents, and even less the operation of the content generating system as a whole.
Furthermore, interpreting at the moment of the user request makes any management of the media used in the service difficult or impossible, especially if the references to these media are created by script commands.
Finally, another disadvantage of JSP technologies is due to the fact that all of the vocabulary words of the description of the service must be words of the final language. It is not possible to make extensions, in the description of the service, which would not be compatible with the final language.
Application design methods also exist which are based solely on a programming language. It is actually possible to include a series of modules in a computer program the functions of which encompass:                creation of a multimedia scene in memory;        management of the interactivity, animation and rendering of said scene;        dialog with a server and interpretation of the responses of said server.        
These approaches enable any type of service to be created, including a very complex mixture of data presentation and computations, which may be required in a game-type application.
On the other hand, these approaches are extremely costly in terms of development time and are poorly suited to broadcasting over a broad range of different terminals, because each application must be tested on each type of terminal.
Finally, techniques based on compiler-type devices only enable a executable code to be generated, the computer languages used at the input often describe basic instructions interpreted and executed by the execution environment and not content-creating rules, and cannot therefore be used within the framework of creating dynamic content.